# Player turn order:
# 1. START_OF_TURN Relics 
# 2. START_OF_TURN Statuses
# 3. Draw Hand
# 4. End Turn 
# 5. END_OF_TURN Relics 
# 6. END_OF_TURN Statuses
# 7. Discard Hand
class_name PlayerHandler
extends Node

const HAND_DRAW_INTERVAL := 0.25
const HAND_DISCARD_INTERVAL := 0.25

var consumed_card_counts: Dictionary = {}

@export var relics: RelicHandler
@export var player: Player
@export var hand: Hand

var character: CharacterStats


func _ready() -> void:
	# 添加到player_handler组中，方便其他节点查找
	add_to_group("player_handler")
	
	Events.card_played.connect(_on_card_played)
	Events.battle_over_screen_requested.connect(_on_battle_over_screen_requested)
	# 连接圣物激活信号
	if relics:
		relics.relics_activated.connect(_on_relics_activated)
	# 连接玩家状态处理信号
	if player and player.status_handler:
		player.status_handler.statuses_applied.connect(_on_statuses_applied)


func start_battle(char_stats: CharacterStats) -> void:
	character = char_stats
	print("主卡组卡牌数量: ", character.deck.cards.size(),"主卡组卡牌数量: ", character.deck.cards.size())
	# 不直接复制整个牌堆，而是创建空的牌堆然后添加独立的卡牌副本
	character.draw_pile = CardPile.new()
	for card in character.deck.cards:
		# 检查卡牌是否为null，避免调用duplicate方法时出错
		if card != null:
			# 战斗开始时，从主卡组复制卡牌，但不重置使用次数
			character.draw_pile.add_card_copy(card, false)
		else:
			print("⚠️ 警告：发现null卡牌，跳过复制")
	character.draw_pile.shuffle()
	character.discard = CardPile.new()
	# 每次战斗开始时清空完全消耗的卡牌记录
	consumed_card_counts.clear()

	# 确保信号连接
	_setup_signal_connections()

	start_turn()


func _setup_signal_connections() -> void:
	# 连接圣物激活信号
	if relics and not relics.relics_activated.is_connected(_on_relics_activated):
		relics.relics_activated.connect(_on_relics_activated)
		print("连接圣物激活信号")

	# 连接玩家状态处理信号
	if player and player.status_handler and not player.status_handler.statuses_applied.is_connected(_on_statuses_applied):
		player.status_handler.statuses_applied.connect(_on_statuses_applied)
		print("连接玩家状态处理信号")


func start_turn() -> void:
	print("🔄 PlayerHandler.start_turn() 开始")
	
	# 在重置参数之前触发PLAYER_START阶段
	# 这个阶段适合在玩家回合开始前应用效果，比如"回合开始时获得护甲"
	_trigger_player_start_phase()
	
	print("	📊 重置前法力: %d" % character.mana)
	
	# 重置玩家状态
	character.block = 0
	character.reset_mana()  # 这里会处理贷款转移，但不发出信号
	
	print("	📊 重置后法力: %d" % character.mana)
	
	# 在能量重置后立即检查回合开始时的能量状态
	# 这可以防止可用能量为0时仍能打牌的问题
	character.check_turn_start_mana()
	
	# 在处理完过量消耗后重置计数器
	print("🔄 重置回合计数器")
	character.reset_turn_counters()
	
	# 在贷款状态完全更新后，统一发出信号更新UI
	# 这样可以确保卡牌UI的可玩性检查基于正确的贷款状态
	character.stats_changed.emit()
	
	# 强制更新手牌中所有卡牌的可玩性状态
	_force_update_hand_playability()
	
	# 激活回合开始时的圣物效果
	# 圣物激活会触发状态效果，状态效果会调用抽牌
	relics.activate_relics_by_type(Relic.Type.START_OF_TURN)

func _trigger_player_start_phase() -> void:
	var battle = get_tree().get_first_node_in_group("battle")
	if battle:
		battle.current_phase = TurnPhaseConstants.PLAYER_START
		print("	触发PLAYER_START阶段 - 玩家回合开始")
		Events.turn_phase_changed.emit(battle.current_turn, battle.current_phase, player)


func end_turn() -> void:
	print("🔄 PlayerHandler.end_turn() 开始")
	# 触发玩家弃牌阶段（在弃牌开始前）
	# 这个阶段适合弃牌相关的效果，比如"弃牌时获得护甲"

	# 在回合结束时处理贷款能量
	print("🔄 准备处理贷款能量...")
	character.end_turn_loan_cleanup()
	
	hand.disable_hand()
	relics.activate_relics_by_type(Relic.Type.END_OF_TURN)


func draw_card() -> void:
	# 如果抽牌堆为空，先尝试从弃牌堆补充
	if character.draw_pile.empty():
		print("📚 抽牌堆为空，尝试从弃牌堆补充...")
		reshuffle_deck_from_discard()
	
	var card = character.draw_pile.draw_card()
	if card:
		hand.add_card(card)
	else:
		print("⚠️ 警告：抽牌堆为空或返回null卡牌")


func draw_cards(amount: int) -> void:
	# 基础检查
	if amount <= 0:
		print("⚠️ 抽牌数量为0或负数，跳过抽牌")
		return
	
	if not character or not character.draw_pile:
		print("❌ 无法访问抽牌堆，跳过抽牌")
		return
	
	print("ready draw %d cards,current draw pile number is %d"%[amount,character.draw_pile.cards.size()])
	
	# 检查抽牌堆是否有足够的卡牌
	var available_cards = character.draw_pile.cards.size()
	if available_cards == 0:
		print("⚠️ 抽牌堆为空，跳过抽牌")
		return
	
	# 确定实际可抽数量（不超过可用卡牌数量）
	var actual_amount = min(amount, available_cards)
	if actual_amount < amount:
		print("⚠️ 抽牌堆不足，目标数量: %d, 实际可抽: %d" % [amount, actual_amount])
	
	print("🎯 开始抽牌，实际数量: %d" % actual_amount)
	
	var tween := create_tween()
	for i in range(actual_amount):
		tween.tween_callback(draw_card)
		tween.tween_interval(HAND_DRAW_INTERVAL)
	
	tween.finished.connect(
		func(): 
			Events.player_hand_drawn.emit()
			print("	抽牌完成，触发PLAYER_MAIN阶段")
			
			# 在抽牌完成后触发玩家主要阶段
			# 这个阶段适合玩家行动相关的效果，此时玩家已有手牌可以行动
			_trigger_player_main_phase()
			
			# 抽牌完成后，强制更新手牌中所有卡牌的可玩性状态
			# 确保新抽到的卡牌和现有卡牌的状态都与当前能量状态同步
			_force_update_hand_playability()
	)


func discard_cards() -> void:
	if hand.get_child_count() == 0:
		Events.player_hand_discarded.emit()
		return

	var tween := create_tween()
	for card_ui in hand.get_children():
		var card: Card = card_ui.card
		if card.card_max_repeat_num == 0:
			# 对于无限使用卡牌，创建副本并重置使用次数
			tween.tween_callback(character.discard.add_card_copy.bind(card, true))
		else:
			# 对于有使用次数限制的卡牌，直接添加以保留使用次数
			tween.tween_callback(character.discard.add_card.bind(card))
		tween.tween_callback(hand.discard_card.bind(card_ui))
		tween.tween_interval(HAND_DISCARD_INTERVAL)
	
	tween.finished.connect(
		func():
			Events.player_hand_discarded.emit()
	)


func reshuffle_deck_from_discard() -> void:
	if not character.draw_pile.empty():
		return
	
	while not character.discard.empty():
		var card: Card = character.discard.draw_card()
		if card.card_max_repeat_num == 0:
			# 对于无限使用卡牌，创建副本并重置使用次数
			character.draw_pile.add_card_copy(card, true)
		else:
			# 对于有使用次数限制的卡牌，直接添加以保留使用次数
			character.draw_pile.add_card(card)
	
	character.draw_pile.shuffle()


func _on_card_played(card: Card) -> void:
# 在函数开始处添加调试信息
	print("处理打出的卡牌: %s, 类型: %d, 最大使用次数: %d, 当前使用次数: %d" %
		[card.id, card.type, card.card_max_repeat_num, card.card_current_repeat_num])
		
	# 对于无限使用型卡牌(card_max_repeat_num == 0)
	if card.card_max_repeat_num == 0:
		# 无限使用型卡牌可以创建副本，且需要重置使用次数
		character.discard.add_card_copy(card, true)
		print("无限使用卡牌，添加副本到弃牌堆")
		return
	
	# 对于有使用次数限制的卡牌
	# 注意：卡牌的使用次数已经在Card.play()方法中减少过了
	if card.card_current_repeat_num > 0:
		# 对于还有使用次数的卡牌，直接添加原卡牌（不创建副本）
		character.discard.add_card(card)
		print("卡牌 %s 添加到弃牌堆，剩余使用次数: %d" % [card.id, card.card_current_repeat_num])
	else:
		# 卡牌使用次数已为0，记录该ID的卡牌消耗数量增加1
		if not card.id in consumed_card_counts:
			consumed_card_counts[card.id] = 0
		consumed_card_counts[card.id] += 1
		print("卡牌 %s 已完全消耗(次数为0)，不添加到弃牌堆，记录消耗数量: %d" % [card.id, consumed_card_counts[card.id]])
	return



func _on_statuses_applied(type: Status.Type) -> void:
	match type:
		Status.Type.START_OF_TURN:
			# 在抽牌前触发PLAYER_DRAW阶段
			# 这个阶段适合修改抽牌数量或跳过抽牌的效果
			_trigger_player_draw_phase()
			
			# 检查抽牌堆是否有卡牌可抽
			if character.draw_pile and not character.draw_pile.empty():
				# 抽牌堆有卡牌，正常抽牌
				draw_cards(character.cards_per_turn)
			else:
				# 抽牌堆为空，先尝试从弃牌堆补充，然后抽牌
				print("📚 回合开始抽牌：抽牌堆为空，尝试从弃牌堆补充...")
				reshuffle_deck_from_discard()
				
				# 补充后再次检查
				if character.draw_pile and not character.draw_pile.empty():
					print("📚 弃牌堆补充完成，开始回合抽牌")
					draw_cards(character.cards_per_turn)
				else:
					print("⚠️ 抽牌堆和弃牌堆都为空，跳过回合开始抽牌")
		Status.Type.END_OF_TURN:
			discard_cards()

func _trigger_player_draw_phase() -> void:
	var battle = get_tree().get_first_node_in_group("battle")
	if battle:
		battle.current_phase = TurnPhaseConstants.PLAYER_DRAW
		print("	触发PLAYER_DRAW阶段 - 准备抽牌")
		Events.turn_phase_changed.emit(battle.current_turn, battle.current_phase, player)


func _trigger_player_main_phase() -> void:
	var battle = get_tree().get_first_node_in_group("battle")
	if battle:
		battle.current_phase = TurnPhaseConstants.PLAYER_MAIN
		print("	触发PLAYER_MAIN阶段 - 玩家主要阶段")
		Events.turn_phase_changed.emit(battle.current_turn, battle.current_phase, player)


func _on_relics_activated(type: Relic.Type) -> void:
	match type:
		Relic.Type.START_OF_TURN:
			player.status_handler.apply_statuses_by_type(Status.Type.START_OF_TURN)
		Relic.Type.END_OF_TURN:
			player.status_handler.apply_statuses_by_type(Status.Type.END_OF_TURN)
# 清理所有卡牌UI，确保不会有UI残留
func clean_up_card_ui() -> void:
	print("清理战斗UI资源...")
	
	# 清理手牌中的所有卡牌UI
	for card_ui in hand.get_children():
		if card_ui is CardUI:
			print("清理手牌中的卡牌UI")
			card_ui.queue_free()
	
	# 确保没有其他UI残留
	Events.card_aim_ended.emit(null)
	Events.card_drag_ended.emit(null)

# 监听战斗结束事件
func _on_battle_over_screen_requested(text: String, type: BattleOverPanel.Type) -> void:
	# 无论战斗胜利还是失败，都清理UI
	clean_up_card_ui()

	# 无论战斗胜利还是失败，都同步卡牌消耗状态到主卡组
	# 这样可以保证消耗性卡牌的使用情况被正确保存
	sync_card_consumption_to_main_deck()
	print("战斗结束，卡牌消耗状态已同步到主卡组")

# 同步消耗类卡牌的使用情况到主卡组
func sync_card_consumption_to_main_deck() -> void:
	if not character or not character.deck:
		return
	
	print("=====================================")
	print("开始同步卡牌消耗状态到主卡组...")
	print("已消耗卡牌统计: ", consumed_card_counts)
	print("=====================================")
	
	# 创建一个字典，用于跟踪每种卡牌ID的消耗状态(剩余使用次数)
	var card_consumption_states: Dictionary = {}
	
	# 收集手牌中的卡牌消耗状态
	for card_ui in hand.get_children():
		var card: Card = card_ui.card
		if card and card.card_max_repeat_num > 0:
			if not card.id in card_consumption_states:
				card_consumption_states[card.id] = []
			card_consumption_states[card.id].append(card.card_current_repeat_num)
			print("收集手牌中的卡牌 %s，当前使用次数: %d" % [card.id, card.card_current_repeat_num])
	
	# 收集抽牌堆中的卡牌消耗状态
	for card: Card in character.draw_pile.cards:
		if card.card_max_repeat_num > 0:
			if not card.id in card_consumption_states:
				card_consumption_states[card.id] = []
			card_consumption_states[card.id].append(card.card_current_repeat_num)
			print("收集抽牌堆中的卡牌 %s，当前使用次数: %d" % [card.id, card.card_current_repeat_num])
	
	# 收集弃牌堆中的卡牌消耗状态
	for card: Card in character.discard.cards:
		if card.card_max_repeat_num > 0:
			if not card.id in card_consumption_states:
				card_consumption_states[card.id] = []
			card_consumption_states[card.id].append(card.card_current_repeat_num)
			print("收集弃牌堆中的卡牌 %s，当前使用次数: %d" % [card.id, card.card_current_repeat_num])
	
	print("=====================================")
	print("收集到的卡牌状态:")
	for card_id in card_consumption_states:
		print("卡牌 %s: 状态列表 %s" % [card_id, card_consumption_states[card_id]])
	print("=====================================")
	
	# 更新主卡组中卡牌的状态
	var main_deck_cards: Array[Card] = character.deck.cards.duplicate()
	character.deck.cards.clear()
	
	# 用于计数已处理的同ID卡牌数量
	var processed_counts: Dictionary = {}
	# 用于记录已经消耗完的卡牌数量
	var fully_consumed_cards := 0
	
	# 对于主卡组中的每张卡牌
	print("处理主卡组中的卡牌...")
	for card: Card in main_deck_cards:
		var card_id = card.id
		
		# 初始化已处理计数
		if not card_id in processed_counts:
			processed_counts[card_id] = 0
		
		# 对于有使用次数限制的卡牌，检查是否已完全消耗
		if card.card_max_repeat_num > 0:
			# 判断这张卡是否应该被标记为已消耗
			var consumed_count = consumed_card_counts.get(card_id, 0)
			
			# 如果已处理的数量小于已消耗的数量，说明这张卡已消耗完
			if processed_counts[card_id] < consumed_count:
				processed_counts[card_id] += 1
				fully_consumed_cards += 1
				print("卡牌 %s (第 %d 张) 已完全消耗，从主卡组移除" % [card_id, processed_counts[card_id]])
				continue
			
			# 如果该ID有卡牌消耗状态，更新使用次数
			if card_id in card_consumption_states and card_consumption_states[card_id].size() > 0:
				var current_repeat_num: int = card_consumption_states[card_id].pop_front()
				
				# 只有当卡牌还有使用次数时才添加回主卡组
				if current_repeat_num > 0:
					var card_copy: Card = card.duplicate(true)
					# 使用收集到的当前使用次数，而不是重置
					card_copy.card_current_repeat_num = current_repeat_num
					# 直接添加，不做额外处理
					character.deck.add_card(card_copy)
					print("更新主卡组中卡牌 %s (第 %d 张)，设置使用次数为: %d" % [card_id, processed_counts[card_id] + 1, current_repeat_num])
				else:
					fully_consumed_cards += 1
					print("卡牌 %s (第 %d 张) 在战斗中用完，从主卡组移除" % [card_id, processed_counts[card_id] + 1])
				
				processed_counts[card_id] += 1
			else:
				# 非消耗类卡牌或没有状态信息的卡牌，直接添加回主卡组
				character.deck.add_card(card)
				processed_counts[card_id] += 1
				print("保留主卡组中的卡牌 %s (第 %d 张)，保持原始使用次数: %d" % [card_id, processed_counts[card_id], card.card_current_repeat_num])
		else:
			# 无限使用卡牌直接添加回主卡组
			character.deck.add_card(card)
			processed_counts[card_id] += 1
			print("添加无限使用卡牌 %s (第 %d 张)" % [card_id, processed_counts[card_id]])
	
	print("=====================================")
	print("同步完成。共有 %d 张卡牌已完全消耗并从主卡组中移除。" % fully_consumed_cards)
	print("剩余卡牌数量: %d" % character.deck.cards.size())
	print("=====================================")
	
	# 清空完全消耗的卡牌记录，为下一场战斗做准备
	consumed_card_counts.clear()

# 强制更新手牌中所有卡牌的可玩性状态
func _force_update_hand_playability() -> void:
	if not hand or not character:
		return
	
	for card_ui in hand.get_children():
		if card_ui is CardUI and card_ui.char_stats:
			# 使用新的方法，考虑修改器影响
			card_ui.playable = character.can_play_card_with_modifiers(card_ui.card, player.modifier_handler)
